Reactivity of Cooperative Systems: Application to ReactiveML -- extended version

Cooperative scheduling enables efficient sequential implementations of concurrency. It is widely used to provide lightweight threads facilities as libraries or programming constructs in many programming languages. However, it is up to programmers to actually cooperate to ensure the reactivity of their programs. We present a static analysis that checks the reactivity of programs by abstracting them into so-called behaviors using a type-and-effect system. Our objective is to find a good compromise between the complexity of the analysis and its precision for typical reactive programs. The simplicity of the analysis is mandatory for the programmer to be able to understand error messages and how to fix reactivity problems. Our work is applied and implemented in the functional synchronous language ReactiveML. It handles recursion, higher-order processes and first-class signals. We prove the soundness of our analysis with respect to the big-step semantics of the language: a well-typed program with reactive effects is reactive. The analysis is easy to implement and generic enough to be applicable to other models of concurrency such as coroutines. This research report is the extended version of the article published at the 21st International Static Analysis Symposium.L'ordonnancement coopératif permet l'implémentation séquentielle efficace de la concurrence. Il est largement utilisé pour fournir des threads légers sous forme de bibliothèques ou de constructions de programmation dans de nombreux langages de programmation. Toutefois, il appartient aux programmeurs d'appeler des primitives de coopération pour assurer la réactivité de leurs programmes. Nous présentons une analyse statique qui vérifie la réactivité des programmes en les abstrayant en comportements à l'aide d'un système de types à effets. Notre objectif est de trouver un bon compromis entre la complexité de l'analyse et sa précision pour les programmes réactifs typiques. La simplicité de l'analyse est obligatoire pour que le programmeur soit en mesure de comprendre les messages d'erreur et comment résoudre les problèmes de réactivité. Notre travail est appliqué et mis en oeuvre dans le langage synchrone fonctionnel ReactiveML. Il gère la récursivité, les processus d'ordre supérieur et les signaux de première classe. Nous prouvons la correction de notre analyse par rapport à la sémantique grands pas du langage~: un programme bien typé avec des effets réactifs est réactif. L'analyse est facile à mettre en oeuvre et assez générique pour être applicable à d'autres modèles de concurrence, tels que les coroutines. Ce rapport de recherche est la version étendue de l'article publié dans les actes de la 21ème édition de l'International Static Analysis Symposium

Réactivité des systèmes coopératifs : le cas de ReactiveML

International audienceLa concurrence coopérative est un modèle de programmation très répandu. On peut par exemple l'utiliser en OCaml à travers des bibliothèques comme Lwt, Async ou Equeue. Il a de nombreux avantages tels que l'absence de courses critiques et des implantations légères et efficaces. Néanmoins, un des inconvénients majeurs de ce modèle est qu'il dépend de la discipline du programmeur pour garantir que le système est réactif : un processus peut empêcher les autres de s'exécuter. ReactiveML est un langage qui étend OCaml avec des constructions de concurrence coopérative. Il propose une analyse statique, l'analyse de réactivité, qui permet de détecter les expressions qui risquent de produire des comportements non coopératifs. Dans cet article, nous présentons cette analyse statique qui se définit à l'aide d'un système de types et effets. Ainsi, comme le typage de données aide les programmeurs à détecter des erreurs d'exécution au plus tôt, l'analyse de réactivité aide à détecter des erreurs de concurrence

Exécution efficace de programmes ReactiveML

National audienceReactiveML est un langage dédié à la programmation de systèmes combinant des parties algorithmiques et réactives. Il s'agit d'une extension de ML avec des constructions pour la concurrence inspirées des langages synchrones. Celles-ci permettent d'obtenir une très grande expressivité, mais leur implantation efficace représente un défi. Dans cet article, nous présentons l'implantation de ReactiveML, de la compilation à l'implantation du moteur d'exécution en OCaml. Nous décrivons également une implantation parallèle en mémoire partagée du moteur d'exécution utilisant le vol de tâches. L'approche choisie permet d'obtenir une exécution efficace même en présence de structures de contrôle complexes. Elle s'étend simplement au cas parallèle avec des résultats expérimentaux prometteurs

Scade 6: from a Kahn Semantics to a Kahn Implementation for Multicore

International audienceSCADE is an environment for developing critical embedded software that is used for more than twenty years in various application domains like avionics, nuclear plants, transportation, automotive. It comes with a language and a code generator which complies with the highest safety standards like DO-178C, IEC 61508, EN 50128, IEC 60880 and ISO 26262. The language has been founded on the pioneering work by Caspi and Halbwachs on Lustre. In 2008, a major revision of the language and compiler, named 'Scade 6', was released. One of its novelty was a smooth integration of the traditional data-flow style of Lustre with control-structures inspired from those of Esterel and SyncCharts, with static/dynamic semantics and a compilation inspired from Lucid Synchrone. In particular, it relies on four dedicated type systems-typing, clock calculus, causality analysis, initialization analysis-and a compilation through source-to-source transformations into a minimal clocked data-flow language, based on a Kahn semantics, that is translated to imperative code. One ongoing work is the generation of code for multi-core architectures. Because of the intrinsic deterministic parallelism of Scade, we propose a solution that relies on annotations that specify what must be executed concurrently but do not change the semantics. The paper is a survey of past to ongoing work on Scade 6 language definition and implementation

A Synchronous Look at the Simulink Standard Library

International audienceHybrid systems modelers like Simulink come with a rich collection of discrete-time and continuous-time blocks. Most blocks are not defined in terms of more elementary ones—and some cannot be—but are instead written in imperative code and explained informally in a reference manual. This raises the question of defining a minimal set of orthogonal programming constructs such that most blocks can be programmed directly and thereby given a specification that is mathematically precise, and whose compiled version performs comparably to handwritten code. In this paper, we show that a fairly large set of blocks of a standard library like the one provided by Simulink can be programmed in a precise, purely functional language using stream equations, hierarchical automata, Ordinary Differential Equations (ODEs), and deterministic synchronous parallel composition. Some blocks cannot be expressed in our setting as they mix discrete-time and continuous-time signals in unprincipled ways that are statically forbidden by the type checker. The experiment is conducted in Zélus, a synchronous language that conservatively extends Lustre with ODEs to program systems that mix discrete-time and continuous-time signals

Raffinement temporel et exécution parallèle dans un langage synchrone fonctionnel

In this thesis, we are interested in the ReactiveML language, which extends ML with constructs inspired from synchronous languages. The idea of these languages is to divide the execution of a program into a succession of discrete logical instants. It results in a deterministic model of concurrency that can be compiled to sequential imperative code. The main application domain of ReactiveML is discrete simulation, for instance of sensor networks. We focus here on the problem of large scale simulation that raises two questions: can we program such simulations easily and modularly? can we execute them efficiently? We answer the first question by proposing an extension of the synchronous model called reactive domains. It allows the creation of local instants, invisible from the outside. It enables temporal refinement, that is, to replace an approximate model of a system with a more detailed version without changing its external behavior. We describe the formal semantics of this construct as well as static analyses, presented as type-and-effect systems, to ensure the soundness of programs in the extended setting. Our second contribution is several parallel implementations of the language to allow the scaling of simulations. We first describe an implementation based on threads communicating by shared memory and using work stealing, and then a second one based on processes communicating by message passing.Nous nous intéressons dans ce manuscrit au langage ReactiveML, qui est une extension de ML avec des constructions inspirées des langages synchrones. L'idée de ces langages est de diviser l'exécution d'un programme en une suite d'instants logiques discrets. Cela permet de proposer un modèle de concurrence déterministe que l'on peut compiler vers du code séquentiel impératif. La principale application de ReactiveML est la simulation discrète, par exemple de réseaux de capteurs. Nous cherchons ici à programmer des simulations à grande échelle, ce qui pose deux questions : sait-on les programmer de façon simple et modulaire ? sait-on ensuite exécuter ces programmes efficacement ? Nous répondons à la première question en proposant une extension du modèle synchrone appelée domaines réactifs. Elle permet de créer des instants locaux invisibles de l'extérieur. Cela rend possible le raffinement temporel, c'est-à-dire le remplacement d'une approximation d'un système par une version plus détaillée sans changer son comportement externe. Nous développons dans ce manuscrit la sémantique formelle de cette construction ainsi que plusieurs analyses statiques, sous forme de systèmes de types-et-effets, garantissant la sûreté des programmes dans le langage étendu. Enfin, nous montrons également plusieurs implémentations parallèles du langage pour tenter de répondre à la question du passage à l'échelle des simulations. Nous décrivons tout d'abord une implémentation avec threads communiquant par mémoire partagée et basée sur le vol de tâches, puis une seconde implémentation utilisant des processus lourds communiquant par envoi de messages

Réactivité des systèmes coopératifs : le cas de ReactiveML

International audienceLa concurrence coopérative est un modèle de programmation très répandu. On peut par exemple l'utiliser en OCaml à travers des bibliothèques comme Lwt, Async ou Equeue. Il a de nombreux avantages tels que l'absence de courses critiques et des implantations légères et efficaces. Néanmoins, un des inconvénients majeurs de ce modèle est qu'il dépend de la discipline du programmeur pour garantir que le système est réactif : un processus peut empêcher les autres de s'exécuter. ReactiveML est un langage qui étend OCaml avec des constructions de concurrence coopérative. Il propose une analyse statique, l'analyse de réactivité, qui permet de détecter les expressions qui risquent de produire des comportements non coopératifs. Dans cet article, nous présentons cette analyse statique qui se définit à l'aide d'un système de types et effets. Ainsi, comme le typage de données aide les programmeurs à détecter des erreurs d'exécution au plus tôt, l'analyse de réactivité aide à détecter des erreurs de concurrence

Raffinement temporel et exécution parallèle dans un langage synchrone fonctionnel

In this thesis, we are interested in the ReactiveML language, which extends ML with constructs inspired from synchronous languages. The idea of these languages is to divide the execution of a program into a succession of discrete logical instants. It results in a deterministic model of concurrency that can be compiled to sequential imperative code. The main application domain of ReactiveML is discrete simulation, for instance of sensor networks. We focus here on the problem of large scale simulation that raises two questions: can we program such simulations easily and modularly? can we execute them efficiently?We answer the first question by proposing an extension of the synchronous model called reactive domains. It allows the creation of local instants, invisible from the outside. It enables temporal refinement, that is, to replace an approximate model of a system with a more detailed version without changing its external behavior. We describe the formal semantics of this construct as well as static analyses, presented as type-and-effect systems, to ensure the soundness of programs in the extended setting. Our second contribution is several parallel implementations of the language to allow the scaling of simulations. We first describe an implementation based on threads communicating by shared memory and using work stealing, and then a second one based on processes communicating by message passing.Nous nous intéressons dans ce manuscrit au langage ReactiveML, qui est une extension de ML avec des constructions inspirées des langages synchrones. L'idée de ces langages est de diviser l'exécution d'un programme en une suite d'instants logiques discrets. Cela permet de proposer un modèle de concurrence déterministe que l'on peut compiler vers du code séquentiel impératif. La principale application de ReactiveML est la simulation discrète, par exemple de réseaux de capteurs. Nous cherchons ici à programmer des simulations à grande Échelle, ce qui pose deux questions: sait-on les programmer de façon simple et modulaire? sait-on ensuite exécuter ces programmes efficacement?Nous répondons à la première question en proposant une extension du modèle synchrone appelée domaines réactifs. Elle permet de créer des instants locaux invisibles de l'extérieur. Cela rend possible le raffinement temporel, c'est-à-dire le remplacement d'une approximation d'un système par une version plus détaillée sans changer son comportement externe. Nous développons dans ce manuscrit la sémantique formelle de cette construction ainsi que plusieurs analyses statiques, sous forme de systèmes de types-et-effets, garantissant la sureté des programmes dans le langage étendu.Enfin, nous montrons également plusieurs implémentations parallèles du langage pour tenter de répondre à la question du passage à l'échelle des simulations. Nous décrivons tout d'abord une implémentation avec threads communiquant par mémoire partagée et basée sur le vol de tâches, puis une seconde implémentation utilisant des processus lourds communiquant par envoi de messages.PARIS-BIUSJ-Mathématiques rech (751052111) / SudocSudocFranceF

Time Refinement in a Functional Synchronous Language

International audienceConcurrent and reactive systems often exhibit multiple time scales. This situation occurs, for instance, in the discrete simulation of a sensor network where the time scale at which agents communicate is very different from the time scale used to model the internals of an agent.The paper presents reactive domains to simplify the programming of such systems. Reactive domains allow for several time scales to be defined and they enable time refinement, that is, the replacement of a system with a more detailed version, without changing its observed behavior.Our work applies to the ReactiveML language, which extends an ML language with synchronous programming constructs a la Esterel. We present an operational semantics for the extended language, a type system that ensures the soundness of programs, and a sequential implementation. We discuss how reactive domains can be used in a parallel implementation

A Model Based Safety Critical Flow for the AURIX Multi-core Platform

International audienceIn this paper, we present a model based development flow for safety critical applications that target parallel execution on Infineon's latest generation AURIX multi-core chips.The flow is based on an extension of SCADE Suite, that generates parallel code from any legacy Scade application. SCADE Suite is a product line of the ANSYS Embedded software family of products and solutions that empowers users with a Model-Based Development Environment for critical embedded software.The generated parallel code is target independent, an integration step is performed to instantiate OS specific services like communication, synchronization or memory protection.An automated integration process has been developed for the PXROS-HR operating system. PXROS-HR, developed by HighTec EDV-Systeme, is a multicore real-time operating system designed for embedded safety-critical applications. PXROS-HR is able to take full advantage of AURIX performance and safety functionalities.SCADE Suite certified generated code embedded in PXROS-HR certified RTOS provide the streamlined answer to challenging development of critical multi-core embedded applications by enabling seamless automated flow from the application model down to executable binary running on a target embedded processor